package com.kstech.mp3604.utils

import java.nio.ByteBuffer
import java.nio.ByteOrder

/**
 * author: blankii
 * created on: 2025/6/16 13:53
 * description:
 */
object DataUtil {
    /*
    无符号十进制转小端序双字节十六进制
    */
    fun intToHex2(number: Int): String {
        require(number in 0..65535) { "Number must be in range 0..65535 (2 bytes)" }

        val lowByte = (number and 0xFF).toByte()   // 低字节（小端序的第一个字节）
        val highByte = (number shr 8).toByte()     // 高字节（小端序的第二个字节）

        return "%02x%02x".format(lowByte, highByte)
    }

    /**
     * 有符号十进制 转小端序 四字节 十六进制
     */
    fun sIntToHex(value: Int): String {
        // 1. 转为 16 位有符号整数（超出范围会截断）
        val shortValue = value.toShort()
        // 2. 转为无符号 16 位整数（负数自动补码）
        val unsignedValue = shortValue.toInt() and 0xFFFF
        // 3. 拆分为高字节和低字节
        val lowByte = unsignedValue and 0xFF
        val highByte = (unsignedValue shr 8) and 0xFF
        // 4. 小端序：低字节在前，高字节在后
        val littleEndianValue = (lowByte shl 8) or highByte
        // 5. 格式化为 4 位十六进制（补零）
        return littleEndianValue.toString(16).padStart(4, '0').uppercase()
    }

    /**
     * 小端序多个字节十六进制转 有符号十进制
     */
    fun hexToSLong(hexStr: String): Long {
//        require(hexStr.length == 8) { "Hex string must be 8 characters (4 bytes)" }

        // 将十六进制字符串转为 ByteArray（小端序）
        val byteArray = hexStr.chunked(2).reversed() // 小端序需反转字节顺序
            .map { it.toInt(16).toByte() }.toByteArray()

        // 使用 ByteBuffer 解析为 Int（自动处理符号），再转为 Long
        return ByteBuffer.wrap(byteArray).order(ByteOrder.BIG_ENDIAN) // 反转后按大端序解析
            .int.toLong()
    }

    /**
     * 小端序 双字节十六进制转 有符号十进制
     */
    fun hexToSInt(hexStr: String): Int {
        require(hexStr.length == 4) { "Hex string must be 2 bytes (4 chars)" }

        // 直接解析为 Int（小端序低字节在前）
        val value = hexStr.toInt(16)
        // 将两个字节交换位置并转为有符号 Short
        return ((value and 0xFF) shl 8 or (value shr 8)).toShort().toInt()
    }

    /**
     * 小端序 双字节十六进制 无符号十进制
     * 1234->13330
     */
    fun hexToUInt(hexStr: String): Int {
        // 确保输入是4个字符的双字节十六进制
        require(hexStr.length == 4) { "输入必须是4个字符的双字节十六进制" }

        // 将小端序转换为大端序
        val bigEndianHex = hexStr.substring(2, 4) + hexStr.substring(0, 2)

        // 将大端序十六进制转换为十进制整数
        return bigEndianHex.toInt(16)
    }

    /*
    十进制转四字节的十六进制
     */
    fun intToHex4(number: Int): String {
        val bytes = ByteArray(4) {
            (number shr (it * 8)).toByte()  // 按小端序拆分字节
        }
        return bytes.joinToString("") { "%02x".format(it) }
    }


    /**
     *     // 测试用例
     *     println(getActualBytesCount("78563412"))  // 4（无 00 结尾）
     *     println(getActualBytesCount("78563400"))  // 3（去除末尾 "00"）
     *     println(getActualBytesCount("78560000"))  // 2（去除末尾 "0000"）
     *     println(getActualBytesCount("78000000"))  // 1（去除末尾 "000000"）
     *     println(getActualBytesCount("00000000"))  // 1（特殊情况，全 0 至少返回 1 字节）
     */
    fun getByteCount(littleEndianHex: String): Int {
        require(littleEndianHex.length == 8) { "Input must be 4-byte (8-character) little-endian hex string" }

        // 1. 去除末尾的 "00"
        val trimmedHex = littleEndianHex.replace(Regex("(00)+$"), "")

        // 2. 计算剩余字符数 / 2 = 实际字节数
        val byteCount = trimmedHex.length / 2

        // 3. 确保结果在 1..4 范围内
        return when (byteCount) {
            0 -> 1  // 如果全部是 "00000000"，至少返回 1 字节
            in 1..4 -> byteCount
            else -> throw IllegalArgumentException("Invalid hex string")
        }
    }

    /**
     * 十六进制大端序转小端序
     */
    fun hexB2L(hexStr: String): String {
        require(hexStr.length % 2 == 0) { "Hex string must have even length" }

        return hexStr.chunked(2).reversed().joinToString("")
    }

    /**
     * 十六进制小端序转大端序
     */
    fun hexL2B(hexString: String): String {
        // 移除可能存在的空格或前缀
        val cleanedStr = hexString.replace(" ", "").replace("0x", "")

        // 确保长度为偶数，必要时在前面补0
        val paddedStr = if (cleanedStr.length % 2 != 0) "0$cleanedStr" else cleanedStr

        // 分割为字节对(每2个字符)
        val bytes = paddedStr.chunked(2)

        // 反转字节顺序并组合
        return bytes.reversed().joinToString("")
    }


    fun hexToBytesArr(hexStr: String): ByteArray {
        val byteArray = ByteArray(hexStr.length / 2)

        for (i in byteArray.indices) {
            val startIndex = i * 2
            val hexByte = hexStr.substring(startIndex, startIndex + 2)
            byteArray[i] = hexByte.toInt(16).toByte()
        }

        return byteArray
    }
}